<!DOCTYPE html>
<html lang="en">

<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>GCC 4.1 Release Series &mdash; Changes, New Features, and Fixes</title>
<link rel="stylesheet" type="text/css" href="https://gcc.gnu.org/gcc.css" />
</head>

<!-- GCC maintainers, please do not hesitate to update/contribute entries
     concerning those part of GCC you maintain!  2002-03-23, Gerald.
-->

<body>
<h1>GCC 4.1 Release Series<br />Changes, New Features, and Fixes</h1>

<p>The latest release in the 4.1 release series is
<a href="#4.1.2">GCC 4.1.2</a>.</p>

<h2>Caveats</h2>

<h2>General Optimizer Improvements</h2>

  <ul>

    <li>GCC now has infrastructure for inter-procedural optimizations and
	the following inter-procedural optimizations are implemented:<br />
	<ul>
	    <li>Profile guided inlining.  When doing profile feedback
		guided optimization, GCC can now use the profile to make
		better informed decisions on whether inlining of a function
		is profitable or not.  This means that GCC will no longer
		inline functions at call sites that are not executed very
		often, and that functions at hot call sites are more likely
		to be inlined.<br />
		A new parameter <code>min-inline-recursive-probability</code>
		is also now available to throttle recursive inlining
		of functions with small average recursive depths.</li>
	    <li>Discovery of <code>pure</code> and <code>const</code>
		functions, a form of side-effects analysis.  While older GCC
		releases could also discover such special functions, the new
		IPA-based pass runs earlier so that the results are available
		to more optimizers.  The pass is also simply more powerful
		than the old one.</li>
	    <li>Analysis of references to static variables and type escape
		analysis, also forms of side-effects analysis.  The results
		of these passes allow the compiler to be less conservative
		about call-clobbered variables and references.  This results
		in more redundant loads being eliminated and in making static
		variables candidates for register promotion.</li>
	    <li>Improvement of RTL-based alias analysis.  The results of type
		escape analysis are fed to the RTL type-based alias analyzer,
		allowing it to disambiguate more memory references.</li>
	    <li>Interprocedural constant propagation and function versioning.
		This pass looks for functions that are always called with the
		same constant value for one or more of the function arguments,
		and propagates those constants into those functions.</li>
	    <li>GCC will now eliminate static variables whose usage was
		optimized out.</li>
	    <li><code>-fwhole-program --combine</code> can now be used to
	        make all functions in program static allowing whole program
		optimization.  As an exception, the <code>main</code> function
		and all functions marked with the new
		<code>externally_visible</code> attribute are kept global so
		that programs can link with runtime libraries.</li>
	</ul></li>

    <li>GCC can now do a form of partial dead code elimination (PDCE) that
	allows code motion of expressions to the paths where the result of
	the expression is actually needed.  This is not always a win, so
	the pass has been limited to only consider profitable cases.  Here
	is an example:

	<pre>
    int foo (int *, int *);
    int
    bar (int d)
    {
      int a, b, c;
      b = d + 1;
      c = d + 2;
      a = b + c;
      if (d)
        {
          foo (&amp;b, &amp;c);
          a = b + c;
        }
      printf ("%d\n", a);
    }
	</pre>

	The <code>a = b + c</code> can be sunk to right before the
	<code>printf</code>.  Normal code sinking will not do this, it will
	sink the first one above into the else-branch of the conditional
	jump, which still gives you two copies of the code.</li>

    <li>GCC now has a value range propagation pass.  This allows the compiler
	to eliminate bounds checks and branches.  The results of the pass
	can also be used to accurately compute branch probabilities.</li>

    <li>The pass to convert PHI nodes to straight-line code (a form of
	if-conversion for GIMPLE) has been improved significantly.  The two
	most significant improvements are an improved algorithm to determine
	the order in which the PHI nodes are considered, and an improvement
	that allow the pass to consider if-conversions of basic blocks with
	more than two predecessors.</li>

    <li>Alias analysis improvements.  GCC can now differentiate between
	different fields of structures in Tree-SSA's virtual operands form.
	This lets stores/loads from non-overlapping structure fields not
	conflict.  A new algorithm to compute points-to sets was contributed
	that can allows GCC to see now that <code>p-&gt;a</code> and
	<code>p-&gt;b</code>, where <code>p</code> is a pointer to a
	structure, can never point to the same field.</li>

    <li>Various enhancements to auto-vectorization:<br />
	<ul>
	    <li>Incrementally preserve SSA form when vectorizing.</li>
	    <li>Incrementally preserve loop-closed form when vectorizing.</li>
	    <li>Improvements to peeling for alignment:
                generate better code when the misalignment of an access
                is known at compile time, or when different accesses are
                known to have the same misalignment, even if the
                misalignment amount itself is unknown.</li>
	    <li>Consider dependence distance in the vectorizer.</li>
	    <li>Externalize generic parts of data reference analysis to
		make this analysis available to other passes.</li>
	    <li>Vectorization of conditional code.</li>
	    <li>Reduction support.</li>
	</ul></li>

    <li>GCC can now partition functions in sections of hot and cold code.
	This can significantly improve performance due to better instruction
	cache locality.  This feature works best together with profile
	feedback driven optimization.</li>

    <li>A new pass to avoid saving of unneeded arguments to the stack in
	<code>vararg</code> functions if the compiler can prove that they
	will not be needed.</li>

    <li>Transition of basic block profiling to tree level implementation has
        been completed.  The new implementation should be considerably more
	reliable (hopefully avoiding profile mismatch errors when using
	<code>-fprofile-use</code> or <code>-fbranch-probabilities</code>) and
	can be used to drive higher level optimizations, such as inlining.
	<p>
	The <code>-ftree-based-profiling</code> command-line option was
	removed and <code>-fprofile-use</code> now implies disabling old RTL
	level loop optimizer (<code>-fno-loop-optimize</code>).  Speculative
	prefetching optimization (originally enabled by
	<code>-fspeculative-prefetching</code>) was removed.</p></li>
  </ul>

 
<h2>New Languages and Language specific improvements</h2>

<h3>C and Objective-C</h3>
  <ul>
    <li>The old Bison-based C and Objective-C parser has been replaced
	by a new, faster hand-written recursive-descent parser.</li>
  </ul>

  <h3>Ada</h3>
  <ul>
    <li>The build infrastructure for the Ada runtime library and tools
	has been changed to be better integrated with the rest of the build
	infrastructure of GCC.  This should make doing cross builds of Ada a
	bit easier.</li>
  </ul>

<h3 id="cplusplus">C++</h3>
  <ul>
    <li>ARM-style name-injection of friend declarations is no longer
        the default.  For example:

	<pre>
          struct S {
            friend void f();
          };

          void g() { f(); }</pre>

        will not be accepted; instead a declaration of <code>f</code>
        will need to be present outside of the scope of
        <code>S</code>.  The new <code>-ffriend-injection</code>
        option will enable the old behavior.</li>

    <li>
     The (undocumented) extension which permitted templates with
     default arguments to be bound to template template parameters with
     fewer parameters has been deprecated, and will be removed in the
     next major release of G++.  For example:

     <pre>
       template &lt;template &lt;typename&gt; class C&gt;
       void f(C&lt;double&gt;) {}

       template &lt;typename T, typename U = int&gt;
       struct S {};

       template void f(S&lt;double&gt;);
     </pre>      

     makes use of the deprecated extension.  The reason this code is
     not valid ISO C++ is that <code>S</code> is a template with two
     parameters; therefore, it cannot be bound to <code>C</code> which
     has only one parameter.
    </li>
  </ul>

  <h4>Runtime Library (libstdc++)</h4>

  <ul>
    <li>Optimization work:
      <ul>
        <li>A new implementation of <code>std::search_n</code> is provided,
	    better performing in case of random access iterators.</li>
	<li>Added further efficient specializations of <code>istream</code>
            functions, i.e., character array and string extractors.</li>
        <li>Other smaller improvements throughout.</li>
      </ul></li>
    <li>Policy-based associative containers, designed for high-performance,
        flexibility and semantic safety are delivered in 
	<code>ext/pb_assoc</code>.</li>
    <li>A versatile string class, <code>__gnu_cxx::__versa_string</code>,
        providing facilities conforming to the standard requirements for
	<code>basic_string</code>, is delivered in
	<code>&lt;ext/vstring.h&gt;</code>.  In particular:
      <ul>
        <li>Two base classes are provided:  the default one avoids reference
	    counting and is optimized for short strings;  the alternate one,
            still uses it while improving in a few low level areas (e.g.,
	    alignment).  See <code>vstring_fwd.h</code> for some useful
	    typedefs.</li>
	<li>Various algorithms have been rewritten (e.g., replace), the code
            streamlined and simple optimizations added.</li>
	<li>Option 3 of DR 431 is implemented for both available bases, thus
            improving the support for stateful allocators.</li>
      </ul></li>
     <li>As usual, many bugs have been fixed (e.g., libstdc++/13583,
         libstdc++/23953) and LWG resolutions put into effect for the first
         time (e.g., DR 280, DR 464, N1780 recommendations for DR 233,
	 TR1 Issue 6.19).  The implementation status of TR1 is now tracked in
	 the docs in <code>tr1.html</code>.</li>
  </ul>

<h3>Objective-C++</h3>
  <ul>
    <li>A new language front end for Objective-C++ has been added.  This language allows
        users to mix the object oriented features of Objective-C with those of C++.</li>
  </ul>

<h3>Java (GCJ)</h3>
  <ul>
    <li>Core library (libgcj) updates based on GNU Classpath 0.15 - 0.19
        features (plus some 0.20 bug-fixes)
      <ul>
        <li>Networking
          <ul>
	    <li>The <code>java.net.HttpURLConnection</code> implementation no
                longer buffers the entire response body in memory.
                This means that response bodies larger than available
                memory can now be handled.</li>
          </ul>
        </li>

        <li>(N)IO
          <ul>
            <li><code>NIO FileChannel.map</code> implementation, fast bulk put
                implementation for <code>DirectByteBuffer</code>
		(speeds up this method 10x).</li>
            <li><code>FileChannel.lock()</code> and
	        <code>FileChannel.force()</code> implemented.</li>
          </ul>
        </li>

        <li>XML
          <ul>
            <li><code>gnu.xml</code> fix for nodes created outside a
	        namespace context.</li>
            <li>Add support for output indenting and cdata-section-elements
                output instruction in <code>xml.transform</code>.</li>
            <li><code>xml.xpath</code> corrections for cases where
                elements/attributes might have been created in
                non-namespace-aware mode.  Corrections to handling of
                XSL variables and minor conformance updates.</li>
          </ul>
        </li>

	<li>AWT
	  <ul>
	    <li>GNU JAWT implementation, the AWT Native Interface,
	    which allows direct access to native screen resources from
	    within a Canvas's paint method.  GNU Classpath Examples
	    comes with a Demo, see
	    <code>libjava/classpath/examples/README</code>.</li>

	    <li><code>awt.datatransfer</code> updated to 1.5 with support
	    for <code>FlavorEvents</code>.  The gtk+ awt peers now allow
	    copy/paste of text, images, URIs/files and serialized objects
	    with other applications and tracking clipboard change events with
	    gtk+ 2.6 (for gtk+ 2.4 only text and serialized objects
	    are supported). A GNU Classpath Examples datatransfer Demo
	    was added to show the new functionality.</li>

	    <li>Split gtk+ awt peers event handling in two threads and
	    improve gdk lock handling (solves several awt lock ups).</li>

	    <li>Speed up awt Image loading.</li>

	    <li>Better gtk+ scrollbar peer implementation when using
	    gtk+ &gt;= 2.6.</li>

	    <li>Handle image loading errors correctly for gdkpixbuf
	    and <code>MediaTracker</code>.</li>

	    <li>Better handle GDK lock. Properly prefix gtkpeer native
	    functions (<code>cp_gtk</code>).</li>

	    <li><code>GdkGraphics2D</code> has been updated to use
	    Cairo 0.5.x or higher.</li>

	    <li><code>BufferedImage</code> and <code>GtkImage</code>
	    rewrites. All image drawing operations should now work
	    correctly (flipping requires gtk+ &gt;= 2.6)</li>

	    <li>When gtk+ 2.6 or higher is installed the default log
	    handler will produce stack traces whenever a WARNING,
	    CRITICAL or ERROR message is produced.</li>
	  </ul>
	</li>

	<li>Free Swing
	  <ul>
	    <li>The <code>RepaintManager</code> has been reworked for more
	    efficient painting, especially for large GUIs.</li>

	    <li>The layout manager <code>OverlayLayout</code> has been
	    implemented, the <code>BoxLayout</code> has been rewritten to
	    make use of the <code>SizeRequirements</code> utility class and
	    caching for more efficient layout.</li>

	    <li>Improved accessibility support.</li>

	    <li>Significant progress has been made in the
	    implementation of the <code>javax.swing.plaf.metal</code>
	    package, with most UI delegates in a working state now.
	    Please test this with your own applications and provide feedback
	    that will help us to improve this package.</li>

	    <li>The GUI demo (<code>gnu.classpath.examples.swing.Demo</code>)
	    has been extended to highlight various features in our
	    Free Swing implementation. And it includes a look and feel
	    switcher for Metal (default), Ocean and GNU themes.</li>

	    <li>The <code>javax.swing.plaf.multi</code> package is now
	    implemented.</li>

	    <li>Editing and several key actions for <code>JTree</code> and
	    <code>JTable</code> were implemented.</li>

	    <li>Lots of icons and look and feel improvements for Free
	    Swing basic and metal themes were added.  Try running the
	    GNU Classpath Swing Demo in examples
	    (<code>gnu.classpath.examples.swing.Demo</code>) with:
	    <code>-Dswing.defaultlaf=javax.swing.plaf.basic.BasicLookAndFeel</code>
	    or
	    <code>-Dswing.defaultlaf=javax.swing.plaf.metal.MetalLookAndFeel</code></li>

	    <li>Start of styled text capabilites for
	    <code>java.swing.text</code>.</li>

	    <li><code>DefaultMutableTreeNode</code> pre-order, post-order,
	    depth-first and breadth-first traversal enumerations
	    implemented.</li>

	    <li><code>JInternalFrame</code> colors and titlebar draw
	    properly.</li>

	    <li><code>JTree</code> is working up to par (icons, selection and
	    keyboard traversal).</li>

	    <li><code>JMenus</code> were made more compatible in visual and
	    programmatic behavior.</li>

	    <li><code>JTable</code> <code>changeSelection</code> and
	    multiple selections implemented.</li>

	    <li><code>JButton</code> and <code>JToggleButton</code> change
	    states work properly now.</li>

	    <li><code>JFileChooser</code> fixes.</li>

	    <li><code>revalidate()</code> and <code>repaint()</code>
	    fixes which make Free Swing much more responsive.</li>

	    <li><code>MetalIconFactory</code> implemented.</li>

	    <li>Free Swing Top-Level Compatibility. <code>JFrame</code>,
	    <code>JDialog</code>, <code>JApplet</code>,
	    <code>JInternalFrame</code>, and <code>JWindow</code> are now
	    1.5 compatible in the sense that you can call <code>add()</code>
	    and <code>setLayout()</code> directly on them, which will have
	    the same effect as calling <code>getContentPane().add()</code>
	    and <code>getContentPane().setLayout()</code>.</li>

	    <li>The <code>JTree</code> interface has been completed.
	    <code>JTree</code>s now recognizes mouse clicks and selections
	    work.</li>

	    <li><code>BoxLayout</code> works properly now.</li>

	    <li>Fixed <code>GrayFilter</code> to actually work.</li>

	    <li>Metal <code>SplitPane</code> implemented.</li>

	    <li>Lots of Free Swing text and editor stuff work now.</li>
	  </ul>
	</li>

	<li>Free RMI and Corba
	  <ul>
	    <li>Andrew Watson, Vice President and Technical
	    Director of the Object Management Group, has officially
	    assigned us 20 bit Vendor Minor Code Id: <code>0x47430</code>
	    ("GC") that will mark remote classpath-specific system
	    exceptions.  Obtaining the VMCID means that GNU Classpath
	    now is a recogniseable type of node in a highly
	    interoperable CORBA world.</li>

	    <li>GNU Classpath now includes the first working draft to
	    support the RMI over IIOP protocol. The current
	    implementation is capable of remote invocations,
	    transferring various Serializables and Externalizables via
	    RMI-IIOP protocol.  It can flatten graphs and, at least
	    for the simple cases, is interoperable with 1.5 JDKs.</li>

	    <li><code>org.omg.PortableInterceptor</code> and related
	    functionality in other packages is now implemented:
	    <ul>
	      <li>The sever and client interceptors work as required
	      since 1.4.</li>
	      <li>The <code>IOR</code> interceptor works as needed for
	      1.5.</li>
	    </ul>
	    </li>

	    <li>The <code>org.omg.DynamicAny</code> package is completed
	    and passes the prepared tests.</li>

	    <li>The Portable Object Adapter should now support the
	    output of the recent IDL to java compilers. These
	    compilers now generate servants and not CORBA objects as
	    before, making the output depend on the existing POA
	    implementation. Completing POA means that such code can
	    already be tried to run on Classpath. Our POA is tested
	    for the following usager scenarios:
	    <ul>
	      <li>POA converts servant to the CORBA object.</li>
	      <li>Servant provides to the CORBA object.</li>
	      <li>POA activates new CORBA object with the given Object
	      Id (byte array) that is later accessible for the
	      servant.</li>
	      <li>During the first call, the ServantActivator provides
	      servant for this and all subsequent calls on the current
	      object.</li>
	      <li>During each call, the ServantLocator provides
	      servant for this call only.</li>
	      <li>ServantLocator or ServantActivator forwards call to
	      another server.</li>
	      <li>POA has a single servant, responsible for all
	      objects.</li>
	      <li>POA has a default servant, but some objects are
	      explicitly connected to they specific servants.</li>
	    </ul>
	    The POA is verified using tests from the former
	    <code>cost.omg.org</code>.</li>

	    <li>The CORBA implementation is now a working prototype
	    that should support features up to 1.3 inclusive.  We
	    invite groups writing CORBA dependent applications
	    to try Classpath implementation, reporting any possible
	    bugs.
	    The CORBA prototype is interoperable with Sun's
	    implementation v 1.4, transferring object references,
	    primitive types, narrow and wide strings, arrays,
	    structures, trees, abstract interfaces and value types
	    (feature of CORBA 2.3) between these two platforms.
	    Remote exceptions are transferred and handled correctly.
	    The stringified object references (IORs) from various
	    sources are parsed as required.  The transient (for
	    current session) and permanent (till jre restart)
	    redirections work.  Both Little and Big Endian encoded
	    messages are accepted.  The implementation is verified
	    using tests from the former cost.omg.org.  The current
	    release includes working examples (see the examples
	    directory), demonstrating the client-server communication,
	    using either CORBA Request or IDL-based stub (usually
	    generated by a IDL to java compiler).  These examples also
	    show how to use the Classpath CORBA naming service.  The
	    IDL to java compiler is not yet written, but as our
	    library must be compatible, it naturally accepts the
	    output of other idlj implementations.</li>
	  </ul>
	</li>

	<li>Misc
	  <ul>

	    <li>Updated <code>TimeZone</code> data against Olson
	    tzdata2005l.</li>

	    <li>Make <code>zip</code> and <code>jar</code> packages UTF-8
	    clean.</li>

	    <li>"native" code builds and compiles (warning free) on
	    Darwin and Solaris.</li>

	    <li><code>java.util.logging.FileHandler</code> now rotates
	    files.</li>

	    <li>Start of a generic JDWP framework in
	    <code>gnu/classpath/jdwp</code>.  This is unfinished,
	    but feedback (at <code>classpath@gnu.org</code>) from
	    runtime hackers is greatly appreciated. Although most of
	    the work is currently being done around <code>gcj/gij</code>
	    we want this framework to be as VM neutral as possible.
	    Early design is described in: <a
	    href="https://gcc.gnu.org/ml/java/2005-05/msg00260.html">
	    https://gcc.gnu.org/ml/java/2005-05/msg00260.html</a></li>

	    <li>QT4 AWT peers, enable by giving configure
	    <code>--enable-qt-peer</code>.  Included, but not ready for
	    production yet. They are explicitly disabled and not supported.
	    But if you want to help with the development of these new
	    features we are interested in feedback. You will have to
	    explicitly enable them to try them out (and they will most
	    likely contain bugs).</li>

	    <li>Documentation fixes all over the place.  See
	    <a href="https://developer.classpath.org/doc/">
	    https://developer.classpath.org/doc/</a></li>
	  </ul>
	</li>
      </ul>
    </li>
  </ul>


<h2 id="targets">New Targets and Target Specific Improvements</h2>

<h3>IA-32/x86-64</h3>
  <ul>
    <li>The x86-64 medium model (that allows building applications whose data
	segment exceeds 4GB) was redesigned to match latest ABI draft.  New
	implementation split large datastructures into separate segment
	improving performance of accesses to small datastructures and also
	allows linking of small model libraries into medium model programs as
	long as the libraries are not accessing the large datastructures
	directly.  Medium model is also supported in position independent code
	now.
        <p>
	The ABI change results in partial incompatibility among medium
	model objects. Linking medium model libraries (or objects) compiled
	with new compiler into medium model program compiled with older will
	likely result in exceeding ranges of relocations.</p>
	<p>
	Binutils 2.16.91 or newer are required for compiling medium model
	now.</p></li>
  </ul>

<h3>RS6000 (POWER/PowerPC)</h3>
  <ul>
    <li>The AltiVec vector primitives in <code>&lt;altivec.h&gt;</code> are
	now implemented in a way that puts a smaller burden on the
	preprocessor, instead processing the "overloading" in the front ends.
	This should benefit compilation speed on AltiVec vector code.</li>
    <li>AltiVec initializers now are generated more efficiently.</li>
    <li>The popcountb instruction available on POWER5 now is generated.</li>
    <li>The floating point round to integer instructions available on
	POWER5+ now is generated.</li>
    <li>Floating point divides can be synthesized using the floating
	point reciprocal estimate instructions.</li>
    <li>Double precision floating point constants are initialized as single
	precision values if they can be represented exactly.</li>
  </ul>

<h3>S/390, zSeries and System z9</h3>
  <ul>
    <li>Support for the IBM System z9 109 processor has been added.  When
	using the <code>-march=z9-109</code> option, the compiler will
	generate code making use of instructions provided by the extended
	immediate facility.</li>
    <li>Support for 128-bit IEEE floating point has been added.  When using
	the <code>-mlong-double-128</code> option, the compiler will map the
	<code>long double</code> data type to 128-bit IEEE floating point.
	Using this option constitutes an ABI change, and requires glibc
	support.</li>
    <li>Various changes to improve performance of generated code have been
	implemented, including:
      <ul>
	<li>In functions that do not require a literal pool, register
	    <code>%r13</code> (which is traditionally reserved as literal pool
	    pointer), can now be freely used for other purposes by the
	    compiler.</li>
	<li>More precise tracking of register use allows the compiler to
	    generate more efficient function prolog and epilog code in certain
	    cases.</li>
	<li>The <code>SEARCH STRING</code>, <code>COMPARE LOGICAL
	    STRING</code>, and <code>MOVE STRING</code> instructions are now
	    used to implement C string functions.</li>
	<li>The <code>MOVE CHARACTER</code> instruction with single byte
	    overlap is now used to implement the <code>memset</code> function
	    with non-zero fill byte.</li>
	<li>The <code>LOAD ZERO</code> instructions are now used where
	    appropriate.</li>
	<li>The <code>INSERT CHARACTERS UNDER MASK</code>, <code>STORE
	    CHARACTERS UNDER MASK</code>, and <code>INSERT IMMEDIATE</code>
	    instructions are now used more frequently to optimize bitfield
	    operations.</li>
	<li>The <code>BRANCH ON COUNT</code> instruction is now used more
	    frequently.  In particular, the fact that a loop contains a
	    subroutine call no longer prevents the compiler from using this
	    instruction.</li>
	<li>The compiler is now aware that all shift and rotate instructions
	    implicitly truncate the shift count to six bits.</li>
      </ul></li>
    <li>Back-end support for the following generic features has been
	implemented:
      <ul>
	<li>The full set of
	    <a href="https://gcc.gnu.org/onlinedocs/gcc-4.1.0/gcc/Atomic-Builtins.html">
	    built-in functions for atomic memory access</a>.</li>
	<li>The <code>-fstack-protector</code> feature.</li>
	<li>The optimization pass avoiding unnecessary stores of incoming 
	    argument registers in functions with variable argument list.</li>
      </ul></li>
  </ul>

<h3>SPARC</h3>
  <ul>
    <li>The default code model in 64-bit mode has been changed from
	Medium/Anywhere to Medium/Middle on Solaris.</li>
    <li>TLS support is disabled by default on Solaris prior to release 10.
	It can be enabled on TLS-capable Solaris 9 versions (4/04 release and
	later) by specifying <code>--enable-tls</code> at configure time.</li>
  </ul>

<h3>MorphoSys</h3>
  <ul>
    <li>Support has been added for this new architecture.</li>
  </ul>

<h2 id="obsolete_systems">Obsolete Systems</h2>

<h2>Documentation improvements</h2>

<h2>Other significant improvements</h2>

  <ul>
    <li>GCC can now emit code for protecting applications from stack-smashing
	attacks.  The protection is realized by buffer overflow detection and
	reordering of stack variables to avoid pointer corruption.</li>

    <li>Some built-in functions have been fortified to protect them against
	various buffer overflow (and format string) vulnerabilities. Compared
	to the mudflap bounds checking feature, the safe builtins have far
	smaller overhead.  This means that programs built using safe builtins
	should not experience any measurable slowdown.</li>
  </ul>

<h2 id="GCC4.1.2">GCC 4.1.2</h2>

<p>This is the <a
href="https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&amp;resolution=FIXED&amp;target_milestone=4.1.2">list
of problem reports (PRs)</a> from GCC's bug tracking system that are
known to be fixed in the 4.1.2 release. This list might not be
complete (that is, it is possible that some PRs that have been fixed
are not listed here).</p>

<p>
  When generating code for a shared library, GCC now recognizes that
  global functions may be replaced when the program runs.  Therefore,
  it is now more conservative in deducing information from the bodies
  of functions.  For example, in this example:
</p>

  <pre>
    void f() {}
    void g() { 
     try { f(); } 
     catch (...) { 
       cout &lt;&lt; "Exception";
     }
    }
  </pre>

<p>
  G++ would previously have optimized away the catch clause, since it
  would have concluded that <code>f</code> cannot throw exceptions.
  Because users may replace <code>f</code> with another function in
  the main body of the program, this optimization is unsafe, and is no
  longer performed.  If you wish G++ to continue to optimize as
  before, you must add a <code>throw()</code> clause to the
  declaration of <code>f</code> to make clear that it does not throw
  exceptions. 
</p>  

</body>
</html>
